Languguage OS 2/Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO/gnu/uucp-doc.lha/uucp-doc-1.04/uucp.info-3

GNU Info File | 1993-02-14 | 51KB | 909 lines

This is Info file uucp.info, produced by Makeinfo-1.49 from the input
file uucp.texi.
   This file documents Taylor UUCP, version 1.04.
   Copyright (C) 1992, 1993 Ian Lance Taylor
   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the section entitled "Copying" are included exactly as in the
original, and provided that the entire resulting derived work is
distributed under the terms of a permission notice identical to this
   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the section entitled "Copying" may be included in
a translation approved by the author instead of in the original English.
File: uucp.info,  Node: Protocol Selection,  Next: File Transfer Control,  Prev: Accepting a Call,  Up: sys File
Protocol Selection
------------------
`protocol STRING'
     Specifies which protocols to use for the other system, and in which
     order to use them.  This would not normally be used.  For example,
     `protocol tfg'.
     The default depends on the characteristics of the port and the
     dialer, as specified by the `seven-bit' and `reliable' commands.
     If neither the port nor the dialer use either of these commands,
     the default is to assume an eight-bit reliable connection.  The
     commands `seven-bit true' or `reliable false' might be used in
     either the port or the dialer to change this.  Each protocol has
     particular requirements that must be met before it will be
     considered during negotiation with the remote side.
     The `t' and `e' protocols are intended for use over TCP or some
     other communication path with end to end reliability, as they do no
     checking of the data at all.  They will only be considered on a
     TCP port which is both reliable and eight bit.
     The `i' protocol is a bidirectional protocol.  It requires an
     eight-bit connection.  It will run over a half-duplex link, such as
     Telebit modems in PEP mode, but for efficient use of such a
     connection you must use the `half-duplex' command (*note port
     File::.).
     The `g' protocol is robust, but requires an eight-bit connection.
     The `G' protocol is the System V Release 4 version of the `g'
     protocol.
     The `a' protocol is a Zmodem like protocol, contributed by Doug
     Evans.  It requires an eight-bit connection, but unlike the `g' or
     `i' protocol it will work if certain control characters may not be
     transmitted.
     The `j' protocol is a variant of the `i' protocol which can avoid
     certain control characters.  The set of characters it avoids can
     be set by a parameter.  While it technically does not require an
     eight bit connection (it could be configured to avoid all
     characters with the high bit set) it would be very inefficient to
     use it over one.  It is useful over a eight-bit connection that
     will not transmit certain control characters.
     The `f' protocol is intended for use with X.25 connections; it
     checksums each file as a whole, so any error causes the entire
     file to be retransmitted.  It requires a reliable connection, but
     only uses seven-bit transmissions.  It is a streaming protocol,
     so, while it can be used on a serial port, the port must be
     completely reliable and flow controlled; many aren't.
     The protocols will be considered in the order shown above.  This
     means that if neither the `seven-bit' nor the `reliable' command
     are used, the `t' protocol will be used over a TCP connection and
     the `i' protocol will be used over any other type of connection
     (subject, of course, to what is supported by the remote system; it
     may be assumed that all systems support the `g' protocol).
     Note that currently specifying both `seven-bit true' and `reliable
     false' will not match any protocol.  If this occurs through a
     combination of port and dialer specifications, you will have to
     use the `protocol' command for the system or no protocol will be
     selected at all (the only reasonable choice would be `protocol f').
     A protocol list may also be specified for a port (*note port
     File::.), but if there is a list for the system the list for the
     port is ignored.
`protocol-parameter CHARACTER STRING ...'
     CHARACTER is a single character specifying a protocol.  The
     remaining strings are a command specific to that protocol which
     will be executed if that protocol is used.  A typical command is
     something like `window 7'.  The particular commands are protocol
     specific.
     The `i' protocol supports the following commands, all of which take
     numeric arguments:
    `window'
          The window size to request the remote system to use.  This
          must be between 1 and 31 inclusive.  The default is 16.
    `packet-size'
          The packet size to request the remote system to use.  This
          must be between 1 and 4095 inclusive.  The default is 1024.
    `remote-window'
          If this is between 1 and 31 inclusive, the window size
          requested by the remote system is ignored and this is used
          instead.  The default is 0, which means that the remote
          system's request is honored.
    `remote-packet-size'
          If this is between 1 and 4095 inclusive, the packet size
          requested by the remote system is ignored and this is used
          instead.  The default is 0, which means that the remote
          system's request is honored.
    `sync-timeout'
          The length of time, in seconds, to wait for a SYNC packet
          from the remote system.  SYNC packets are exchanged when the
          protocol is started.  The default is 10.
    `sync-retries'
          The number of times to retry sending a SYNC packet before
          giving up. The default is 6.
    `timeout'
          The length of time, in seconds, to wait for an incoming
          packet before sending a negative acknowledgement.  The
          default is 10.
    `retries'
          The number of times to retry sending a packet or a negative
          acknowledgement before giving up and closing the connection.
          The default is 6.
    `errors'
          The maximum number of errors to permit before closing the
          connection. The default is 100.
    `error-decay'
          The rate at which to ignore errors.  Each time this many
          packets are received, the error count is decreased by one, so
          that a long connection with an occasional error will not
          exceed the limit set by `errors'. The default is 10.
     The `g' and `G' protocols support the following commands, all of
     which take numeric arguments, except `short-packets' which takes a
     boolean argument:
    `window'
          The window size to request the remote system to use.  This
          must be between 1 and 7 inclusive.  The default is 7.
    `packet-size'
          The packet size to request the remote system to use.  This
          must be a power of 2 between 32 and 4096 inclusive.  The
          default is 64, which is the only packet size supported by
          many older UUCP packages.  Some UUCP packages will even dump
          core if a larger packet size is requested.
    `startup-retries'
          The number of times to retry the initialization sequence.
          The default is 8.
    `init-retries'
          The number of times to retry one phase of the initialization
          sequence (there are three phases).  The default is 4.
    `init-timeout'
          The timeout in seconds for one phase of the initialization
          sequence.  The default is 10.
    `retries'
          The number of times to retry sending either a data packet or
          a request for the next packet.  The default is 6.
    `timeout'
          The timeout in seconds when waiting for either a data packet
          or an acknowledgement.  The default is 10.
    `garbage'
          The number of unrecognized bytes to permit before dropping the
          connection.  This must be larger than the packet size.  The
          default is 10000.
    `errors'
          The number of errors (malformed packets, out of order
          packets, bad checksums, or packets rejected by the remote
          system) to permit before dropping the connection.  The
          default is 100.
    `error-decay'
          The rate at which to ignore errors.  Each time this many
          packets are received, the error count is decreased by one, so
          that a long connection with an occasional error will not
          exceed the limit set by `errors'. The default is 10.
    `remote-window'
          If this is between 1 and 7 inclusive, the window size
          requested by the remote system is ignored and this is used
          instead.  This can be useful when dealing with some poor UUCP
          packages.  The default is 0, which means that the remote
          system's request is honored.
    `remote-packet-size'
          If this is between 32 and 4096 inclusive the packet size
          requested by the remote system is ignored and this is used
          instead.  There is probably no good reason to use this.  The
          default is 0, which means that the remote system's request is
          honored.
    `short-packets'
          If this is true, then the code will optimize by sending
          shorter packets when there is less data to send.  This
          confuses some UUCP packages, such as System V Release 4 (when
          using the `G' protocol) and Waffle; when connecting to such a
          package, this parameter must be set to false. The default is
          true for the `g' protocol and false for the `G' protocol.
     The `a' protocol is a Zmodem like protocol contributed by Doug
     Evans.  It supports the following commands, all of which take
     numeric arguments except for `escape-control', which takes a
     boolean argument:
    `timeout'
          Number of seconds to wait for a packet to arrive.  The
          default is 10.
    `retries'
          The number of times to retry sending a packet.  The default
          is 10.
    `startup-retries'
          The number of times to retry sending the initialization
          packet.  The default is 4.
    `garbage'
          The number of garbage characters to accept before closing the
          connection.  The default is 2400.
    `send-window'
          The number of characters that may be sent before waiting for
          an acknowledgement.  The default is 1024.
    `escape-control'
          Whether to escape control characters.  If this is true, the
          protocol may be used over a connection which does not
          transmit certain control characters, such as `XON' or `XOFF'.
           The connection must still transmit eight bit characters
          other than control characters.  The default is false.
     The `j' protocol can be used over an eight bit connection that will
     not transmit certain control characters.  It accepts the same
     protocol parameters that the `i' protocol accepts, as well as one
     more:
    `avoid'
          A list of characters to avoid.  This is a string which is
          interpreted as an escape sequence (*note Chat Scripts::.).
          The protocol does not have a way to avoid printable ASCII
          characters (byte values from 32 to 126, inclusive); only
          ASCII control characters and eight-bit characters may be
          avoided.  The default value is `\021\023'; these are the
          characters `XON' and `XOFF' which many connections use for
          flow control.  If the package is configured to use
          `HAVE_BSD_TTY', then on some versions of Unix you may have to
          avoid `\377' as well, due to the way some implementations of
          the BSD terminal driver handle signals.
     The `f' protocol is intended for use with error-correcting modems
     only; it checksums each file as a whole, so any error causes the
     entire file to be retransmitted.  It supports the following
     commands, both of which take numeric arguments:
    `timeout'
          The timeout in seconds before giving up.  The default is 120.
    `retries'
          How many times to retry sending a file.  The default is 2.
     The `t' and `e' protocols are intended for use over TCP or some
     other communication path with end to end reliability, as they do no
     checking of the data at all.  They both support a single command,
     which takes a numeric argument:
    `timeout'
          The timeout in seconds before giving up.  The default is 120.
     The protocol parameters are reset to their default values after
     each call.
File: uucp.info,  Node: File Transfer Control,  Next: Miscellaneous (sys),  Prev: Protocol Selection,  Up: sys File
File Transfer Control
---------------------
`send-request BOOLEAN'
     The BOOLEAN determines whether the remote system is permitted to
     request files from the local system.  The default is yes.
`receive-request BOOLEAN'
     The BOOLEAN determines whether the remote system is permitted to
     send files to the local system.  The default is yes.
`request BOOLEAN'
     A shorthand command, equivalent to specifying both `send-request
     BOOLEAN' and `receive-request BOOLEAN'.
`call-transfer BOOLEAN'
     The BOOLEAN is checked when the local system places the call.  It
     determines whether the local system may do file transfers queued
     up for the remote system.  The default is yes.
`called-transfer BOOLEAN'
     The BOOLEAN is checked when the remote system calls in.  It
     determines whether the local system may do file transfers queued
     up for the remote system.  The default is yes.
`transfer BOOLEAN'
     Equivalent to specifying both `call-transfer BOOLEAN'
     `called-transfer BOOLEAN'.
`call-local-size NUMBER STRING'
     The STRING is a time string (*note Time Strings::.).  The NUMBER
     is the size in bytes of the largest file that should be
     transferred at a time matching the time string if the local system
     placed the call and the request was made by the local system.  This
     command may appear multiple times in a single alternate.  If this
     command does not appear, or if none of the time strings match,
     there are no size restrictions.
     With all the size control commands, the size of a file from the
     remote system (as opposed to a file from the local system) will
     only be checked if the other system is running this package; other
     UUCP packages will not understand a maximum size request, nor will
     they inform this package of the size of remote files.
`call-remote-size NUMBER STRING'
     Specify the size in bytes of the largest file that should be
     transferred at a given time by remote request when the local system
     placed the call.  This command may appear multiple times in a
     single alternate.  If this command does not appear, there are no
     size restrictions.
`called-local-size NUMBER STRING'
     Specify the size in bytes of the largest file that should be
     transferred at a given time by local request when the remote
     system placed the call. This command may appear multiple times in
     a single alternate. If this command does not appear, there are no
     size restrictions.
`called-remote-size NUMBER STRING'
     Specify the size in bytes of the largest file that should be
     transferred at a given time by remote request when the remote
     system placed the call.  This command may appear multiple times in
     a single alternate. If this command does not appear, there are no
     size restrictions.
`local-send STRINGS'
     Specifies that files in the directories named by the STRINGS may
     be sent to the remote system when requested locally (using `uucp'
     or `uux').  The directories in the list should be separated by
     whitespace.  A `~' may be used for the public directory.  On a Unix
     system, this is typically `/usr/spool/uucppublic'; the public
     directory may be set with the `pubdir' command.  Here is an example
     of `local-send':
          local-send ~ /usr/spool/ftp/pub
     Listing a directory allows all files within the directory and all
     subdirectories to be sent.  Directories may be excluded by
     preceding them with an exclamation point.  For example:
          local-send /usr/ftp !/usr/ftp/private ~
     means that all files in `/usr/ftp' or the public directory may be
     sent, except those files in `/usr/ftp/private'.  The list of
     directories is read from left to right, and the last directory to
     apply takes effect; this means that directories should be listed
     from top down.  The default is the root directory (i.e., any file
     at all may be sent by local request).
`remote-send STRINGS'
     Specifies that files in the named directories may be sent to the
     remote system when requested by the remote system.  The default is
     `~'.
`local-receive STRINGS'
     Specifies that files may be received into the named directories
     when requested by a local user.  The default is `~'.
`remote-receive STRINGS'
     Specifies that files may be received into the named directories
     when requested by the remote system.  The default is `~'.  On
     Unix, the remote system may only request that files be received
     into directories that are writeable by the world, regardless of
     how this is set.
`forward-to STRINGS'
     Specifies a list of systems to which files may be forwarded.  The
     remote system may forward files through the local system on to any
     of the systems in this list.  The string `ANY' may be used to
     permit forwarding to any system.  The default is to not permit
     forwarding to other systems.  Note that if the remote system is
     permitted to execute the `uucp' command, it effectively has the
     ability to forward to any system.
`forward-from STRINGS'
     Specifies a list of systems from which files may be forwarded.  The
     remote system may request files via the local system from any of
     the systems in this list.  The string `ANY' may be used to permit
     forwarding to any system.  The default is to not permit forwarding
     from other systems.  Note that if a remote system is permitted to
     execute the `uucp' command, it effectively has the ability to
     request files from any system.
`forward STRINGS'
     Equivalent to specifying both `forward-to STRINGS' and
     `forward-from STRINGS'.  This would normally be used rather than
     either of the more specific commands.
File: uucp.info,  Node: Miscellaneous (sys),  Next: Default sys File Values,  Prev: File Transfer Control,  Up: sys File
Miscellaneous sys File Commands
-------------------------------
`sequence BOOLEAN'
     If BOOLEAN is true, then conversation sequencing is automatically
     used for the remote system, so that if somebody manages to spoof
     as the remote system, it will be detected the next time the remote
     system actually calls.  This is false by default.
`command-path STRING'
     Specifies the path (a list of whitespace separated directories) to
     be searched to locate commands to execute.  This is only used for
     commands requested by `uux', not for chat programs.  The default
     is from `policy.h'.
`commands STRINGS'
     The list of commands which the remote system is permitted to
     execute locally.  For example: `commands rnews rmail'.  If the
     value is `ALL' (case significant), all commands may be executed.
     The default is `rnews rmail'.
`free-space NUMBER'
     Specify the minimum amount of file system space (in bytes) to
     leave free after receiving a file.  If the incoming file will not
     fit, it will be rejected.  This initial rejection will only work
     when talking to another instance of this package, since older UUCP
     packages do not provide the file size of incoming files.  Also,
     while a file is being received, `uucico' will periodically check
     the amount of free space.  If it drops below the amount given by
     the `free-space' command, the file transfer will be aborted.  The
     default amount of space to leave free is from `policy.h'.  This
     file space checking may not work on all systems.
`pubdir STRING'
     Specifies the public directory that is used when `~' is specifed in
     a file transfer or a list of directories.  This essentially
     overrides the public directory specified in the main configuration
     file for this system only.  The default is the public directory
     specified in the main configuration file (which defaults to a
     value from `policy.h').
`debug STRING ...'
     Set additional debugging for calls to or from the system.  This
     may be used to debug a connection with a specific system.  It is
     particularly useful when debugging incoming calls, since debugging
     information will be generated whenever the call comes in.  See the
     `debug' command in the main configuration file (*note Debugging
     Levels::.) for more details.  The debugging information specified
     here is in addition to that specified in the main configuration
     file or on the command line.
`max-remote-debug STRING ...'
     When the system calls in, it may request that the debugging level
     be set to a certain value.  This command may be used to put a
     limit on the debugging level which the system may request, to
     avoid filling up the disk with debugging information.  Only the
     debugging types named in the `max-remote-debug' command may be
     turned on by the remote system. To prohibit any debugging, use
     `max-remote-debug none'.  The default is
     `abnormal,chat,handshake'; to turn off these default entries, you
     must use `max-remote-debug none' followed by other
     `max-remote-debug' commands specifying the settings you want.
File: uucp.info,  Node: Default sys File Values,  Prev: Miscellaneous (sys),  Up: sys File
Default sys File Values
-----------------------
   The following are used as default values for all systems; they can be
considered as appearing before the start of the file.
     time Never
     chat "" \r\c ogin:-BREAK-ogin:-BREAK-ogin: \L word: \P
     chat-timeout 10
     callback n
     sequence n
     request y
     transfer y
     local-send /
     remote-send ~
     local-receive ~
     remove-receive ~
     command-path [ from `policy.h' ]
     commands rnews rmail
     max-remote-debug abnormal,chat,handshake
File: uucp.info,  Node: port File,  Next: dial File,  Prev: sys File,  Up: Configuration Files
The Port Configuration File
===========================
   The port files may be used to name and describe ports.  Any commands
in the file before the first `port' command specify defaults for all
ports in the file.  All commands after a `port' command up to the next
`port' command then describe that port.  There are different types of
ports; each type supports its own set of commands.  Each command
indicates which types of ports support it.  There may be many ports
with the same name; if a system requests a port by name then each port
with that name will be tried until an unlocked one is found.
`port STRING'
     Introduces and names a port.
`type STRING'
     Define the type of port.  The default is `modem'.  If this command
     appears, it must immediately follow the `port' command.  The type
     defines what commands are subsequently allowed.  Currently the
     types are:
    `modem'
          For a modem hookup.
    `stdin'
          For a connection through standard input and standard output,
          as when `uucico' is run as a login shell.
    `direct'
          For a direct connection to another system.
    `tcp'
          For a connection using TCP.
    `tli'
          For a connection using TLI.
`protocol STRING'
     Specify a list of protocols to use for this port.  This is just
     like the corresponding command for a system (*note Protocol
     Selection::.).  A protocol list for a system takes precedence over
     a list for a port.
`protocol-parameter CHARACTER STRINGS [ any type ]'
     The same command as the `protocol-parameter' command used for
     systems (*note Protocol Selection::.).  This one takes precedence.
`seven-bit BOOLEAN [ any type ]'
     This is only used during protocol negotiation; if the argument is
     true, it forces the selection of a protocol which works across a
     seven-bit link.  It does not prevent eight bit characters from
     being transmitted. The default is false.
`reliable BOOLEAN [ any type ]'
     This is only used during protocol negotiation; if the argument is
     false, it forces the selection of a protocol which works across an
     unreliable communication link.  The default is true.  It would be
     more common to specify this for a dialer rather than a port.
`half-duplex BOOLEAN [ any type ]'
     If the argument is true, it means that the port only supports
     half-duplex connections.  This only affects bidirectional
     protocols, and causes them to not do bidirectional transfers.
`device STRING [ modem, direct and tli only ]'
     Names the device associated with this port.  If the device is not
     named, the port name is taken as the device.  Device names are
     system dependent.  On Unix, a modem or direct connection might be
     something like `/dev/ttyd0'; a TLI port might be `/dev/inet/tcp'.
`baud NUMBER [ modem and direct only ]'
`speed NUMBER [modem and direct only ]'
     The speed this port runs at.  If a system specifies a speed but no
     port name, then all ports which match the speed will be tried in
     order.  If the speed is not specified here and is not specified by
     the system, the natural speed of the port will be used by default.
`baud-range NUMBER NUMBER [ modem only ]'
`speed-range NUMBER NUMBER [ modem only ]'
     Specify a range of speeds this port can run at.  The first number
     is the minimum speed, the second number is the maximum speed.
     These numbers will be used when matching a system which specifies
     a desired speed. The simple `speed' (or `baud') command is still
     used to determine the speed to run at if the system does not
     specify a speed. For example, the command `speed-range 300 19200'
     means that the port will match any system which uses a speed from
     300 to 19200 baud (and will use the speed specified by the
     system); this could be combined with `speed 2400', which means
     that when this port is used with a system that does not specify a
     speed, the port will be used at 2400 baud.
`carrier BOOLEAN [ modem only ]'
     The argument indicates whether the port supports carrier.  If it
     does not, carrier will never be required on this port, regardless
     of what the modem chat script indicates.  The default is true.
`dial-device STRING [ modem only ]'
     Dialing instructions should be output to the named device, rather
     than to the normal port device.  The default is to output to the
     normal port device.
`dialer STRING [ modem only ]'
     Name a dialer to use.  The information is looked up in the dialer
     file. There is no default.  Some sort of dialer information must
     be specified to call out on a modem.
`dialer STRING ... [ modem only ]'
     Execute a dialer command.  If a dialer is named (by using the
     first form of this command, described just above), these commands
     are ignored. They may be used to specify dialer information
     directly in simple situations without needing to go to a separate
     file.  There is no default.  Some sort of dialer information must
     be specified to call out on a modem.
`dialer-sequence STRINGS [ modem or tli only ]'
     Name a sequence of dialers and tokens (phone numbers) to use.  The
     first argument names a dialer, and the second argument names a
     token.  The third argument names another dialer, and so on.  If
     there are an odd number of arguments, the phone number specified
     with a `phone' command in the system file is used as the final
     token.  The token is what is used for `\D' or `\T' in the dialer
     chat script.  If the token in this string is `\D', the system
     phone number will be used; if it is `\T', the system phone number
     will be used after undergoing dialcodes translation.  A missing
     final token is taken as `\D'.
     This command currently does not work if `dial-device' is specified;
     to handle this correctly will require a more systematic notion of
     chat scripts.  Moreover, only the `complete' and `abort' chat
     scripts from the first dialer specified are used, and only the
     protocol parameters from the first dialer are used.
     This command basically lets you specify a sequence of chat scripts
     to use.  For example, the first dialer might get you to a local
     network and the second dialer might describe how to select a
     machine from the local network.  This lets you break your dialing
     sequence into simple modules, and may make it easier to share
     dialer entries between machines.
     When this command is used with a TLI port, then if the first
     dialer is `TLI' or `TLIS' the first token is used as the address to
     connect to.  If the first dialer is something else, or if there is
     no token, the address given by the `address' command is used
     (*note Placing the Call::.).  Escape sequences in the address are
     expanded as they are for chat script expect strings (*note Chat
     Scripts::.).  The different between `TLI' and `TLIS' is that the
     latter implies the command `stream true'.  These contortions are
     all for HDB compatibility.  Any subsequent dialers are treated as
     they are for a modem.
`lockname STRING [ modem and direct only ]'
     Give the name to use when locking this port.  On Unix, this is the
     name of the file that will be created in the lock directory.  It
     is used as is, so on Unix it should generally start with `LCK..'.
     For example, if a single port were named both `/dev/ttycu0' and
     `/dev/tty0' (perhaps with different characteristics keyed on the
     minor device number), then the command `lockname LCK..ttycu0' could
     be used to force the latter to use the same lock file name as the
     former.
`service STRING [ tcp only ]'
     Name the TCP port number to use.  This may be a number.  If not,
     it will be looked up in `/etc/services'.  If this is not
     specified, the string `uucp' is looked up in `/etc/services'.  If
     it is not found, port number 540 (the standard UUCP-over-TCP port
     number) will be used.
`push STRINGS [ tli only ]'
     Give a list of modules to push on to the TLI stream.
`stream BOOLEAN [ tli only ]'
     If this is true, and the `push' command was not used, the `tirdwr'
     module is pushed on to the TLI stream.
`server-address STRING [ tli only ]'
     Give the address to use when running as a TLI server.  Escape
     sequences in the address are expanded as they are for chat script
     expect strings (*note Chat Scripts::.).
File: uucp.info,  Node: dial File,  Next: Security,  Prev: port File,  Up: Configuration Files
The Dialer Configuration File
=============================
   The dialer configuration files define dialers.  Any commands in the
file before the first `dialer' command specify defaults for all the
dialers in the file.  All commands after a `dialer' command up to the
next `dialer' command are associated with the named dialer.
`dialer STRING'
     Introduces and names a dialer.
`chat STRINGS'
`chat-timeout NUMBER'
`chat-fail STRING'
`chat-seven-bit BOOLEAN'
`chat-program STRINGS'
     Specify a chat script to be used to dial the phone.  See *Note
     Chat Scripts:: for full details on chat scripts.
     Taylor UUCP will sleep for one second between attempts to dial out
     on a modem.  If your modem requires a longer wait period, you must
     start your chat script with delays (`\d' in a send string).
     The chat script will be read from and sent to the port specified
     by the `dial-device' command for the port, if there is one.
     The following escape addition escape sequences may appear in send
     strings:
    `\D'
          send phone number without dialcode translation
    `\T'
          send phone number with dialcode translation
    `\M'
          do not require carrier
    `\m'
          require carrier (fail if not present)
     See the description of the dialcodes file (*note Configuration
     File Names::.) for a description of dialcode translation.  If the
     port does not support carrier (as set by the `carrier' command in
     the port file) `\M' and `\m' are ignored.  If both the port and
     the dialer support carrier (as set by the `carrier' command in the
     port file and the `carrier' command in the dialer file), then
     every chat script implicitly begins with `\M' and ends with `\m'.
     There is no default chat script for dialers.
     The following additional escape sequences may be used in
     `chat-program':
    `\D'
          phone number without dialcode translation
    `\T'
          phone number with dialcode translation
     If the program changes the port in any way (e.g., sets parity) the
     changes will be preserved during protocol negotiation, but once the
     protocol is selected it will change the port settings.
`dialtone STRING'
     A string to output when dialing the phone number which causes the
     modem to wait for a secondary dial tone.  This is used to
     translate the `=' character in a phone number.  The default is a
     comma.
`pause STRING'
     A string to output when dialing the phone number which causes the
     modem to wait for 1 second.  This is used to translate the `-'
     character in a phone number.  The default is a comma.
`carrier BOOLEAN'
     If the argument is true, the dialer supports the modem carrier
     signal. After the phone number is dialed, `uucico' will require
     that carrier be on.  One some systems, it will be able to wait for
     it.  If the argument is false, carrier will not be required.  The
     default is true.
`carrier-wait NUMBER'
     If the port is supposed to wait for carrier, this may be used to
     indicate how many seconds to wait.  The default is 60 seconds.
     Only some systems support waiting for carrier.
`dtr-toggle BOOLEAN BOOLEAN'
     If the first argument is true, then DTR is toggled before using
     the modem.  This is only supported on some systems and some ports.
      The second BOOLEAN need not be present; if it is, and it is true,
     the program will sleep for 1 second after toggling DTR. The
     default is not to toggle DTR.
`complete-chat STRINGS'
`complete-chat-timeout NUMBER'
`complete-chat-fail STRING'
`complete-chat-seven-bit BOOLEAN'
`complete-chat-program STRINGS'
     These commands define a chat script (*note Chat Scripts::.) which
     is run when a call is finished normally.  This allows the modem to
     be reset. There is no default.  No additional escape sequences may
     be used.
`complete STRING'
     This is a simple use of `complete-chat'.  It is equivalent to
     `complete-chat "" STRING'; this has the effect of sending STRING
     to the modem when a call finishes normally.
`abort-chat STRINGS'
`abort-chat-timeout NUMBER'
`abort-chat-fail STRING'
`abort-chat-seven-bit BOOLEAN'
`abort-chat-program STRINGS'
     These commands define a chat script (*note Chat Scripts::.) to be
     run when a call is aborted.  They may be used to interrupt and
     reset the modem.  There is no default.  No additional escape
     sequences may be used.
`abort STRING'
     This is a simple use of `abort-chat'.  It is equivalent to
     `abort-chat "" STRING'; this has the effect of sending STRING to
     the modem when a call is aborted.
`protocol-parameter CHARACTER STRINGS'
     Set protocol parameters, just like the `protocol-parameter' command
     in the system configuration file or the port configuration file;
     see *Note Protocol Selection::.  These parameters take precedence,
     then those for the port, then those for the system.
`seven-bit BOOLEAN'
     This is only used during protocol negotiation; if it is true, it
     forces selection of a protocol which works across a seven-bit
     link.  It does not prevent eight bit characters from being
     transmitted.  The default is false.  It would be more common to
     specify this for a port than for a dialer.
`reliable BOOLEAN'
     This is only used during protocol negotiation; if it is false, it
     forces selection of a protocol which works across an unreliable
     communication link.  The default is true.
`half-duplex BOOLEAN [ any type ]'
     If the argument is true, it means that the dialer only supports
     half-duplex connections.  This only affects bidirectional
     protocols, and causes them to not do bidirectional transfers.
File: uucp.info,  Node: Security,  Prev: dial File,  Up: Configuration Files
Security
========
   This discussion of UUCP security applies only to Unix.  It is a bit
cursory; suggestions for improvement are solicited.
   UUCP is traditionally not very secure.  Taylor UUCP addresses some
security issues, but is still far from being a secure system.
   If security is very important to you, then you should not permit any
external access to your computer, including UUCP.  Any opening to the
outside world is a potential security risk.
   By default Taylor UUCP provides few mechanisms to secure local users
of the system from each other.  You can allow increased security by
putting the owner of the UUCP programs (normally `uucp') into a separate
group; the use of this is explained in the following paragraphs, which
refer to this separate group as `uucp-group'.
   When the `uucp' program is invoked to copy a file to a remote
system, it will by default copy the file into the UUCP spool directory.
When the `uux' program is used, the `-C' switch must be used to copy
the file into the UUCP spool directory.  In any case, once the file has
been copied into the spool directory, other local users will not be
able to access it.
   When a file is requested from a remote system, UUCP will only permit
it to be placed in a directory which is writable by the requesting user.
The directory must also be writable by UUCP.  A local user can create a
directory with a group of `uucp-group' and set the mode to permit group
write access.  This will allow the file be requested without permitting
it to be viewed by any other user.
   There is no provision for security for `uucp' requests (as opposed
to `uux' requests) made by a user on a remote system.  A file sent over
by a remote request may only be placed in a directory which is world
writable, and the file will be world readable and writable.  This will
permit any local user to destroy or replace the contents of the file.
A file requested by a remote system must be world readable, and the
directory it is in must be world readable.  Any local user will be able
to examine, although not necessarily modify, the file before it is sent.
   There are some security holes and race conditions that apply to the
above discussion which I will not elaborate on.  They are not hidden
from anybody who reads the source code, but they are somewhat technical
and difficult (though scarcely impossible) to exploit.  Suffice it to
say that even under the best of conditions UUCP is not completely
secure.
   For many sites, security from remote sites is a more important
consideration.  Fortunately, Taylor UUCP does provide some support in
this area.
   The greatest security is provided by always dialing out to the other
site.  This prevents anybody from pretending to be the other site.  Of
course, only one side of the connection can do this.
   If remote dialins must be permitted, then it is best if the dialin
line is used only for UUCP.  If this is the case, then you should
create a call-in password file (*note Configuration File Names::.) and
let `uucico' do its own login prompting.  For example, to let remote
sites log in on a port named `entry' in the port file (*note port
File::.) you might invoke `uucico -p entry'.  This would cause `uucico'
to enter an endless loop of login prompts and daemon executions.  The
advantage of this approach is that even if remote users break into the
system by guessing or learning the password, they will only be able to
do whatever `uucico' permits them to do.  They will not be able to
start a shell on your system.
   If remote users can dial in and log on to your system, then you have
a security hazard more serious than that posed by UUCP.  But then, you
probably knew that already.
   Once your system has connected with the remote UUCP, there is a fair
amount of control you can exercise.  You can use the `remote-send' and
`remote-receive' commands to control the directories the remote UUCP
can access.  You can use the `request' command to prevent the remote
UUCP from making any requests of your system at all; however, if you do
this it will not even be able to send you mail or news.  If you do
permit remote requests, you should be careful to restrict what commands
may be executed at the remote system's request.  The default is `rmail'
and `rnews', which will suffice for most systems.
   If different remote systems call in and they must be granted
different privileges (perhaps some systems are within the same
organization and some are not) then the `called-login' command should
be used for each system to require that they different login names.
Otherwise it would be simple for a remote system to use the `myname'
command and pretend to be a different system.  The `sequence' command
can be used to detect when one system pretended to be another, but
since the sequence numbers must be reset manually after a failed
handshake this can sometimes be more trouble than it's worth.
File: uucp.info,  Node: Protocols,  Next: Hacking,  Prev: Configuration Files,  Up: Top
UUCP protocol internals
***********************
   This chapter describes how the various UUCP protocols work, and
discusses some other internal UUCP issues.
   This chapter is quite technical.  You do not need to understand it,
or even read it, in order to use Taylor UUCP.  It is intended for people
who are interested in how UUCP code works.
   This chapter is also, unfortunately, somewhat out of date, although I
believe that is incomplete rather than inaccurate.  I post this
information to the newsgroups `comp.mail.uucp' and `news.answers' each
month; if you want to write code based on this information, please get
the most recent copy.
   Most of the discussion covers the protocols used by all UUCP
packages, not just Taylor UUCP.  Any information specific to Taylor
UUCP is indicated as such.  There are some pointers to the actual
functions in the Taylor UUCP source code, for those who are extremely
interested in actual UUCP implementation.
* Menu:
* Grades::                      UUCP grades
* Lock Files::                  UUCP lock file format
* UUCP Protocol::               The common UUCP protocol
* g Protocol::                  The UUCP `g' protocol
* f Protocol::                  The UUCP `f' protocol
* t Protocol::                  The UUCP `t' protocol
* e Protocol::                  The UUCP `e' protocol
* x Protocol::                  The UUCP `x' protocol
* d Protocol::                  The UUCP `d' protocol
* Capital G Protocol::          The UUCP `G' protocol
* Documentation References::    Documentation references
File: uucp.info,  Node: Grades,  Next: Lock Files,  Prev: Protocols,  Up: Protocols
UUCP Grades
===========
   Modern UUCP packages support grades for each command.  The grades
generally range from `A' (the highest) to `Z' followed by `a' to `z'.
Taylor UUCP also supports `0' to `9' before `A'.  Some UUCP packages
may permit any ASCII character as a grade.
   On Unix, these grades are encoded in the name of the command file.  A
command file name generally has the form
     C.nnnngssss
where NNNN is the remote system name for which the command is queued, G
is a single character grade, and SSSS is a four character sequence
number.  For example, a command file created for the system `airs' at
grade `Z' might be named
     C.airsZ2551
   The remote system name will be truncated to seven characters, to
ensure that the command file name will fit in the 14 character file
name limit of the traditional Unix file system.  UUCP packages which
have no other means of distinguishing which command files are intended
for which systems thus require all *systems they connect to* to have
names that are unique in the first seven characters.  Some UUCP
packages use a variant of this format which truncates the system name
to six characters.  HDB uses a different spool directory format, which
allows up to fourteen characters to be used for each system name.  The
Taylor UUCP spool directory format is configurable.  The new Taylor
spool directory format permits system names to be as long as file
names; the maximum length of a file name depends on the particular Unix
file system being used.
   The sequence number in the command file name may be a decimal
integer, or it may be a hexadecimal integer, or it may contain any
alphanumeric character.  Different UUCP packages are different.
   Taylor UUCP creates command files in the function
`zsysdep_spool_commands'.  The file name is constructed by the function
`zsfile_name', which knows about all the different types of spool
directories supported by Taylor UUCP.  The Taylor UUCP sequence number
can contain any alphanumeric character; the next sequence number is
determined by the function `fscmd_seq'.
   I do not know how command grades are handled in non-Unix UUCP
packages.
   Modern UUCP packages allow you to restrict file transfer by grade
depending on the time of day.  Typically this is done with a line in
the `Systems' (or `L.sys') file like this:
     airs Any/Z,Any2305-0855 ...
   This allows only grades `Z' and above to be transferred at any time.
 Lower grades may only be transferred at night.  I believe that this
grade restriction applies to local commands as well as to remote
commands, but I am not sure.  It may only apply if the UUCP package
places the call, not if it is called by the remote system.  Taylor UUCP
can use the `timegrade' and `call-timegrade' commands (*note When to
Call::.) to achieve the same effect (and supports the above format when
reading `Systems' or `L.sys').
   This sort of grade restriction is most useful if you know what grades
are being used at the remote site.  The default grades used depend on
the UUCP package.  Generally `uucp' and `uux' have different defaults.
A particular grade can be specified with the `-g' option to `uucp' or
`uux'.  For example, to request execution of rnews on airs with grade
`d', you might use something like
     uux -gd - airs!rnews <article
   `uunet' queues up mail at grade `Z' and news at grade `d'.  The
example above would allow mail to be received at any time, but would
only permit news to be transferred at night.
File: uucp.info,  Node: Lock Files,  Next: UUCP Protocol,  Prev: Grades,  Up: Protocols
UUCP Lock File Format
=====================
   This discussion applies only to Unix.  I have no idea how UUCP locks
ports on other systems.
   UUCP creates files to lock serial ports and systems.  On most (if not
all) systems, these same lock files are also used by cu to coordinate
access to serial ports.  On some systems getty also uses these lock
files.
   The lock file normally contains the process ID of the locking
process. This makes it easy to determine whether a lock is still valid.
 The algorithm is to create a temporary file and then link it to the
name that must be locked.  If the link fails because a file with that
name already exists, the existing file is read to get the process ID.
If the process still exists, the lock attempt fails.  Otherwise the
lock file is deleted and the locking algorithm is retried.
   Older UUCP packages put the lock files in the main UUCP spool
directory, /usr/spool/uucp.  HDB UUCP generally puts the lock files in
a directory of their own, usually /usr/spool/locks or /etc/locks.
   The original UUCP lock file format encoded the process ID as a four
byte binary number.  The order of the bytes was host-dependent.  HDB
UUCP stores the process ID as a ten byte ASCII decimal number, with a
trailing newline.  For example, if process 1570 holds a lock file, it
would contain the eleven characters space, space, space, space, space,
space, one, five, seven, zero, newline.  Some versions of UUCP add a
second line indicating which program created the lock (uucp, cu, or
getty).  I have also seen a third type of UUCP lock file which did not
contain the process ID at all.
   The name of the lock file is generally "LCK.." followed by the base
name of the device.  For example, to lock /dev/ttyd0 the file LCK..ttyd0
would be created.  There are various exceptions.  On SCO Unix, the lock
file name is always forced to lower case even if the device name has
upper case letters.  System V Release 4 UUCP forms the lock file name
using the major and minor device numbers rather than the device name
(this is pretty sensible if you think about it).
   Taylor UUCP can be configured to use various different types of
locking. The actual locking code is in the function `fsdo_lock'.
File: uucp.info,  Node: UUCP Protocol,  Next: g Protocol,  Prev: Lock Files,  Up: Protocols
The Common UUCP Protocol
========================
   The UUCP protocol is a conversation between two UUCP packages.  A
UUCP conversation consists of three parts: an initial handshake, a
series of file transfer requests, and a final handshake.
   Before the initial handshake, the caller will usually have logged in
the called machine and somehow started the UUCP package there.  On Unix
this is normally done by setting the shell of the login name used to
`uucico'.
* Menu:
* Initial Handshake::           Initial handshake
* File Requests::               File requests
* Final Handshake::             Final handshake